#include <vcl.h>
#pragma hdrstop

#include "eic.h"
#include "MTAG_Outils.h"
#include "uParamCourrierEtCarnAdr.h" //Pour GetRepsCourrier
#include "CAccesCourrier.h"

#pragma package(smart_init)
#define MODULE_TAG MTAG_CACCESCOURRIER
#define NOM_DLL_EDITEUR "EICEdito.dll"
//---------------------------------------------------------------------------
// ValidCtrCheck est utilisé est utilisé pour être sûr que les composants créés n'ont
// aucune fonction virtuelle pure.
//

static inline void ValidCtrCheck(CAccesCourrier *)
{
  new CAccesCourrier(NULL);
}
//---------------------------------------------------------------------------
__fastcall CAccesCourrier::CAccesCourrier(TComponent* Owner)
  : TComponent(Owner)
{
AnsiString   aFileNameEicEdito;
try
   {
   hEditeur = NULL;
   _MigrerTables = NULL;
   _TexteModeleExists = NULL;
   _VerifierModele = NULL;
   _ImporterModele = NULL;
   _ImporterModeleSecondaire = NULL;
   _InstallerModele = NULL;
   _CreerModeleSecondaire = NULL;
   _VerifierVariable = NULL;
   _SupprimerVariable = NULL;
   _IniCoordParDefaut = NULL;
   _CompleteCoordParDefaut = NULL;
   _GetListeEmetDest = NULL;
   _RenommerModele = NULL;
   _SupprimerModele = NULL;
   _SupprimerModelesSecondaire = NULL;
   _ModifierModele = NULL;
   _DonneesSontTrouveesDansTable = NULL;
   _GetNomFichier = NULL;
   _GetDescriptifModele = NULL;
   _EnregistrerModReq = NULL;

   if (!ComponentState.Contains(csDesigning))
      {
      GetRepsCourrier(&aFileNameEicEdito);
      aFileNameEicEdito += NOM_DLL_EDITEUR;
      if((hEditeur = LoadLibrary(aFileNameEicEdito.c_str())) == NULL)
         throw EAbort("Librairie "+ aFileNameEicEdito + " absente");
      }

   }
catch (Exception &e)
 {
   EICDisplayException(TAG(0),e);
 }
}
//---------------------------------------------------------------------------
__fastcall CAccesCourrier::~CAccesCourrier()
{
  try
    {
    FreeLibrary(hEditeur);
    hEditeur = NULL;
    }
  catch (Exception &e)
    {
      EICDisplayException(TAG(10),e);
    }
}
/*******************************************************************************
bool __fastcall CAccesCourrier::ListeModelesEditeur(const AnsiString &aLogiciel,
                                                    const AnsiString &aCategorie,
                                                    TStringList *slListeDesModeles)

Fonction : Remplie les caractéristiques des courriers disponibles pour le logiciel et la catégorie spécifiée

P.E : aLogiciel  : Logiciel utilisé pour filtrer les courriers à sélectionner. Peut être vide
      aCategorie : Catégorie utilisér pour filtrer les courriers à sélectionner. Peut être vide

P.E modifié:
   ListeDesCourriers  : Chaque ligne est constitutée de : Logiciel\r\nCategorie\r\nLibellé\r\nVal. paramétrée 1\r\nVal. paramétrée 2\n\n1 : si c'est un courrier créé par l'utilisateur
                        Le contenu de chaque ligne peut être mis dans une structure avec la fonction AnsiStringToTDescriptifModele

P.S :
*******************************************************************************/
bool __fastcall CAccesCourrier::ListeModelesEditeur(const AnsiString &aLogiciel,
                                                    const AnsiString &aCategorie,
                                                    TStringList *slListeDesModeles)
{
FctListeModeles   _ListeModeles = NULL;
tMaillonListeCourrier *PremierMaillon = NULL, *MaillonPrec = NULL, *MaillonCourant = NULL;
try
   {
   ASSERT(hEditeur);
   if (!_ListeModeles)
      {
      _ListeModeles = (FctListeModeles)GetProcAddress(hEditeur, "_ListeModeles" );
      if( !_ListeModeles )
        throw EAbort("Impossible de charger la fonction _ListeModeles");
      }

   PremierMaillon = _ListeModeles(aLogiciel, aCategorie);

   MaillonCourant = PremierMaillon;
   while (MaillonCourant)
      {
      slListeDesModeles->Add(  MaillonCourant->sDescriptifModele.aLogiciel               + "\r\n"
                             + MaillonCourant->sDescriptifModele.aCategorie              + "\r\n"
                             + MaillonCourant->sDescriptifModele.aLibelle                + "\r\n"
                             + AnsiString(MaillonCourant->sDescriptifModele.shValParam1) + "\r\n"
                             + AnsiString(MaillonCourant->sDescriptifModele.shValParam2) + "\r\n"
                             + (MaillonCourant->sDescriptifModele.bIsModeleUtilisateur ? "1" : "0"));

      MaillonPrec = MaillonCourant;
      MaillonCourant = MaillonCourant->MaillonSuiv;
      delete MaillonPrec;          MaillonPrec = NULL;
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(20), e);
   }
return (slListeDesModeles->Count != 0);
}

/*******************************************************************************
void __fastcall CAccesCourrier::AnsiStringToTDescriptifModele(const AnsiString &aChaineDescriptive,
                                                              TDescriptifModele *sDescriptifModele) const

Fonction : Déconcatène une chaîne de caractèrisqtie (retournée par la fonction ListeCourriersEditeur)
           dans une structure de type TDescriptifModele.

Paramètres d'entrée : aChaineDescriptive

Paramètres de sortie : sDescriptifModele
*******************************************************************************/
void __fastcall CAccesCourrier::AnsiStringToTDescriptifModele(const AnsiString &aChaineDescriptive,
                                                              TDescriptifModele *sDescriptifModele) const
{
TStringList *slDescriptif = NULL;
try
   {
   slDescriptif = new TStringList;
   slDescriptif->Text = aChaineDescriptive; //La TStringList va s'occuper de la découper
   sDescriptifModele->aLogiciel            = slDescriptif->Strings[0];
   sDescriptifModele->aCategorie           = slDescriptif->Strings[1];
   sDescriptifModele->aLibelle             = slDescriptif->Strings[2];
   sDescriptifModele->shValParam1          = slDescriptif->Strings[3].ToInt();
   sDescriptifModele->shValParam2          = slDescriptif->Strings[4].ToInt();
   sDescriptifModele->bIsModeleUtilisateur = (slDescriptif->Strings[5][1] != '0');
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(25), e);
   }
delete slDescriptif;      slDescriptif = NULL;
}

/*******************************************************************************
bool __fastcall CAccesCourrier::GenererFichiersCourrier(const AnsiString &aLogiciel,
                                                        const AnsiString &aCategorie,
                                                        const AnsiString &aLibelle,
                                                        IDLangue eLangue,
                                                        IDOrientation eOrientation,
                                                        unsigned long NoCoord,
                                                        TStringList *ListeFichiers,
                                                        GetValueOfVarEvent FonctionGetValueOfVar,
                                                        TMiseEnPage *Rect,
                                                        const AnsiString &aRepSecondaire = EmptyStr,
                                                        eNivModele eNoModeleSecondaire = eNivPrimaire
                                                        )

Fonction : Génére le courrier au format RTF.
ATTENTION : C'est à l'appelant de supprimer les fichiers qui ont été généré et dont les
            chemins sont spécifiés dans ListeFichiers

Paramètres d'entrée : aLogiciel    : Logiciel du modèle
                      aCategorie   : Catégorie du modèle
                      aLibelle     : Libellé du modèle
                      eLangue      : Langue du modèle
                      eOrientation : Orientation du modèle
                      NoCoord      : Coordonnées des émetteurs/destinataires (0 si inutilisé)
                      FonctionGetValueOfVar : Pointeur sur la fonction Callback qui remplira
                                              le contenu des variables du modèle.
                      aRepSecondaire : Si un répertoire secondaire est précisé, le modèle pris
                                       en compte sera celui de ce répertoire.
                      eNoModeleSecondaire : Numéro d'ordre du modèle secondaire

Paramètres de sortie : ListeFichiers : Chemins des fichiers RTF générés.
                                       L'indice 0 correspond au fichier contenant l'en-tête.
                                       L'indice 1 correspond au fichier contenant le pied de page.
                                       Le reste correspond aux fichiers constituant le corps.
                      Rect : Marges utilisées lors de la mise en page du modèle.

Valeur retournée : true si le courrier a été généré.
*******************************************************************************/
bool __fastcall CAccesCourrier::GenererFichiersCourrier(const AnsiString &aLogiciel,
                                                        const AnsiString &aCategorie,
                                                        const AnsiString &aLibelle,
                                                        IDLangue eLangue,
                                                        IDOrientation eOrientation,
                                                        unsigned long NoCoord,
                                                        TStringList *ListeFichiers,
                                                        GetValueOfVarEvent FonctionGetValueOfVar,
                                                        TMiseEnPage *Rect,
                                                        const AnsiString &aRepSecondaire/* = EmptyStr*/,
                                                        eNivModele eNoModeleSecondaire /*= eNivPrimaire*/
                                                        )
{
FctGenererFichiersCourrier   _GenererFichiersCourrier = NULL;
try
   {
   ASSERT(hEditeur);
   ASSERT(ListeFichiers->Count == 0); //La liste sera remplie par la fonction

   if (!_GenererFichiersCourrier)
      {
      _GenererFichiersCourrier = (FctGenererFichiersCourrier)GetProcAddress(hEditeur, "_GenererFichiersCourrier" );
      if( !_GenererFichiersCourrier )
        throw EAbort("Impossible de charger la fonction _GenererFichiersCourrier");
      }
   return _GenererFichiersCourrier(aLogiciel, aCategorie, aLibelle,
                                   eLangue, eOrientation,
                                   NoCoord,
                                   ListeFichiers, FonctionGetValueOfVar, Rect,
                                   aRepSecondaire,
                                   eNoModeleSecondaire);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(30), e);
   }
   
return false;
}

//---------------------------------------------------------------------------
namespace Caccescourrier
{
  void __fastcall PACKAGE Register()
  {
     TComponentClass classes[1] = {__classid(CAccesCourrier)};
     RegisterComponents("EIC Outils", classes, 0);
  }
}

/*******************************************************************************
bool __fastcall CAccesCourrier::MigrerTables()

Fonction :

P.E :

P.S :
*******************************************************************************/
bool __fastcall CAccesCourrier::MigrerTables()
{
try
   {
   if (!_MigrerTables)
      {
      _MigrerTables = (FctMigrerTables)GetProcAddress(hEditeur, "_MigrerTables");
      if(!_MigrerTables)
         throw EAbort("Impossible de charger la fonction _MigrerTables");
      }

   return _MigrerTables();
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(40), e);
   return false;
   }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres modifiés :

Valeur retournée :
*******************************************************************************/
bool __fastcall CAccesCourrier::TexteModeleExists(const AnsiString &aLogiciel,
                                                  const AnsiString &aCategorie,
                                                  const AnsiString &aLibelle,
                                                  IDLangue eLangue,
                                                  IDOrientation eOrientation)
{
bool bRetour = false;
try
   {
   if (!_TexteModeleExists)
      {
      _TexteModeleExists = (FctTexteModeleExists)GetProcAddress(hEditeur, "_TexteModeleExists");
      if(!_TexteModeleExists)
         throw EAbort("Impossible de charger la fonction _TexteModeleExists");
      }

   bRetour = _TexteModeleExists(aLogiciel, aCategorie, aLibelle, eLangue, eOrientation);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(40), e);
   bRetour = false;
   }
return bRetour;
}

/*******************************************************************************
bool __fastcall CAccesCourrier::VerifierCourrier(const AnsiString &aLogiciel,
                                                 const AnsiString &aCategorie,
                                                 const AnsiString &aCourrier,
                                                 const AnsiString &aLibelle,
                                                 IDLangue eLangue,
                                                 IDOrientation eOrientation,
                                                 short shParam1,
                                                 short shParam2)

Fonction : Vérifie l'existence du Courrier "aCourrier" dans la table et ajoute cet
           enregistrement si le fichier RTF correspondant existe.

P.E : aCourrier  : Nom du fichier RTF du courrier à vérifier
   Les variables suivantes sont utilisées uniquement pour compléter la table si l'enregistrement est absent.
      aLogiciel    : Logiciel du courrier
      aCategorie   : Nom de la catégorie associée au courrier
      aLibelle     : Libellé du courrier
      eLangue      : Langue du modèle
      eOrientation : Orientation du modèle
      shParam1     : Indice de la valeur paramétrée dans la TStringList associée à cette colonne paramétrée
      shParam2     : Indice de la valeur paramétrée dans la TStringList associée à cette colonne paramétrée

P.S : false si le fichier rtf n'existe pas.
*******************************************************************************/
bool __fastcall CAccesCourrier::VerifierCourrier(const AnsiString &aLogiciel,
                                                 const AnsiString &aCategorie,
                                                 const AnsiString &aCourrier,
                                                 const AnsiString &aLibelle,
                                                 IDLangue eLangue,
                                                 IDOrientation eOrientation,
                                                 short shParam1,
                                                 short shParam2)
{
bool bRetour = false;
try
   {
   ASSERT(!aCourrier.IsEmpty() && !aLibelle.IsEmpty());
   ASSERT(!aLogiciel.AnsiPos(";"));
   if (!_VerifierModele)
      {
      _VerifierModele = (FctVerifierModele)GetProcAddress(hEditeur, "_VerifierModele");
      if(!_VerifierModele)
         throw EAbort("Impossible de charger la fonction _VerifierModele");
      }

   bRetour = _VerifierModele(aCourrier, aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, shParam1, shParam2);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(42), e);
   bRetour = false;
   }
return bRetour;
}

/*******************************************************************************
bool __fastcall ImporterModele(const AnsiString &aFichier,
                               bool bRemplacer,
                               const AnsiString &aLogiciel,
                               const AnsiString &aCategorie,
                               const AnsiString &aLibelle,
                               IDLangue eLangue = lngFRANCAIS,
                               IDOrientation eOrientation = eOrLibre,
                               short shParam1 = 0,
                               short shParam2 = 0);

Fonction : Importe un fichier RTF en tant que modèle utilisateur

P.E : aFichier  : Nom du fichier RTF à importer
      bRemplacer   : Remplace le modèle s'il existe déjà
      aLogiciel    : Logiciel du courrier
      aCategorie   : Nom de la catégorie associée au courrier
      aLibelle     : Libellé du courrier
      eLangue      : Langue du modèle
      eOrientation : Orientation du modèle
      shParam1     : Indice de la valeur paramétrée dans la TStringList associée à cette colonne paramétrée
      shParam2     : Indice de la valeur paramétrée dans la TStringList associée à cette colonne paramétrée

Valeur retournée : 
*******************************************************************************/
bool __fastcall CAccesCourrier::ImporterModele(const AnsiString &aFichier,
                                               bool bRemplacer,
                                               const AnsiString &aLogiciel,
                                               const AnsiString &aCategorie,
                                               const AnsiString &aLibelle,
                                               IDLangue eLangue/* = lngFRANCAIS*/,
                                               IDOrientation eOrientation/* = eOrLibre*/,
                                               short shParam1/* = 0*/,
                                               short shParam2/* = 0*/)
{
try
   {
   ASSERT(!aFichier.IsEmpty() && !aLogiciel.IsEmpty() && !aCategorie.IsEmpty() &&!aLibelle.IsEmpty());
   ASSERT(!aLogiciel.AnsiPos(";") && !aCategorie.AnsiPos(";"));
   if (!_ImporterModele)
      {
      _ImporterModele = (FctImporterModele)GetProcAddress(hEditeur, "_ImporterModele");
      if(!_ImporterModele)
         throw EAbort("Impossible de charger la fonction _ImporterModele");
      }

   return _ImporterModele(aFichier, bRemplacer,
                          aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, shParam1, shParam2);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(45), e);
   }
return false;
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres modifiés :

Valeur retournée :
*******************************************************************************/
bool __fastcall CAccesCourrier::ImporterModeleSecondaire(const AnsiString &aFichier,
                                                         bool bRemplacer,
                                                         const AnsiString &aLogiciel,
                                                         const AnsiString &aCategorie,
                                                         const AnsiString &aLibelle,
                                                         IDLangue eLangue,
                                                         IDOrientation eOrientation,
                                                         const AnsiString &aRepSecondaire,
                                                         eNivModele eNoModeleSecondaire
                                                         )
{
try
   {
   ASSERT(!aFichier.IsEmpty() && !aLogiciel.IsEmpty() && !aCategorie.IsEmpty() &&!aLibelle.IsEmpty() && !aRepSecondaire.IsEmpty());
   ASSERT(!aLogiciel.AnsiPos(";") && !aCategorie.AnsiPos(";"));
   if (!_ImporterModeleSecondaire)
      {
      _ImporterModeleSecondaire = (FctImporterModeleSecondaire)GetProcAddress(hEditeur, "_ImporterModeleSecondaire");
      if(!_ImporterModeleSecondaire)
         throw EAbort("Impossible de charger la fonction _ImporterModeleSecondaire");
      }

   return _ImporterModeleSecondaire(aFichier, bRemplacer,
                                    aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, aRepSecondaire, eNoModeleSecondaire);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(46), e);
   }
return false;
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres modifiés :

Valeur retournée :
*******************************************************************************/
bool __fastcall CAccesCourrier::InstallerModele(const AnsiString &aFichier,
                                                const AnsiString &aLogiciel,
                                                const AnsiString &aCategorie,
                                                const AnsiString &aLibelle,
                                                IDLangue eLangue,
                                                IDOrientation eOrientation,
                                                short shParam1,
                                                short shParam2)
{
try
   {
   ASSERT(!aFichier.IsEmpty() && !aLogiciel.IsEmpty() && !aCategorie.IsEmpty() &&!aLibelle.IsEmpty());
   ASSERT(!aLogiciel.AnsiPos(";") && !aCategorie.AnsiPos(";"));
   if (!_InstallerModele)
      {
      _InstallerModele = (FctInstallerModele)GetProcAddress(hEditeur, "_InstallerModele");
      if(!_InstallerModele)
         throw EAbort("Impossible de charger la fonction _InstallerModele");
      }

   return _InstallerModele(aFichier,
                           aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, shParam1, shParam2);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(47), e);
   }
return false;
}


/*******************************************************************************
bool __fastcall CAccesCourrier::CreerModeleSecondaire(const AnsiString &aLogiciel,
                                                      const AnsiString &aCategorie,
                                                      const AnsiString &aLibelle,
                                                      IDLangue eLangue,
                                                      IDOrientation eOrientation,
                                                      const AnsiString &aRepSecondaire,
                                                      eNivModele eNoModeleSource,
                                                      eNivModele eNoModeleCible
                                                      )

Fonction :

Paramètres d'entrée : eNoModeleSource : Modèle qui devra être pris comme source.
                                        Si eNoModeleSource vaut eNivAucun, le modèle
                                        créé sera vide.

Paramètres modifiés :

Valeur retournée :
*******************************************************************************/
bool __fastcall CAccesCourrier::CreerModeleSecondaire(const AnsiString &aLogiciel,
                                                      const AnsiString &aCategorie,
                                                      const AnsiString &aLibelle,
                                                      IDLangue eLangue,
                                                      IDOrientation eOrientation,
                                                      const AnsiString &aRepSecondaire,
                                                      eNivModele eNoModeleSource,
                                                      eNivModele eNoModeleCible
                                                      )
{
try
   {
   ASSERT(!aLogiciel.IsEmpty() && !aCategorie.IsEmpty() &&!aLibelle.IsEmpty());
   ASSERT(!aLogiciel.AnsiPos(";") && !aCategorie.AnsiPos(";"));
   if (!_CreerModeleSecondaire)
      {
      _CreerModeleSecondaire = (FctCreerModeleSecondaire)GetProcAddress(hEditeur, "_CreerModeleSecondaire");
      if(!_CreerModeleSecondaire)
         throw EAbort("Impossible de charger la fonction _CreerModeleSecondaire");
      }

   return _CreerModeleSecondaire(aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, aRepSecondaire, eNoModeleSource, eNoModeleCible);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(48), e);
   }
return false;
}

/*******************************************************************************
bool __fastcall CAccesCourrier::VerifierVariable(const AnsiString &aLogiciel,
                                                 const AnsiString &aCategorie,
                                                 const AnsiString &aNom,
                                                 const AnsiString &aLibelle,
                                                 const AnsiString &aValeur)

Fonction : Vérifie l'existence de la variable "aNom" dans la table et l'ajoute si elle
           n'existe pas

P.E : aNom  : Nom de la variable à vérifier
   Les variables suivantes sont utilisées uniquement pour compléter la table si l'enregistrement est absent.
      aCategorie : Nom de la catégorie associée à la variable
      aLibelle   : Libellé de la variable
      aValeur    : Valeur de la variable
      aLogiciel  : Logiciel du courrier
      bIsModifiableParUtilisateur : Indique si la variable peut être modifiée par l'utilisateur

P.S : false si la variable ne peut être créée.
*******************************************************************************/
bool __fastcall CAccesCourrier::VerifierVariable(const AnsiString &aLogiciel,
                                                 const AnsiString &aCategorie,
                                                 const AnsiString &aNom,
                                                 const AnsiString &aLibelle,
                                                 const AnsiString &aValeur,
                                                 bool bIsModifiableParUtilisateur)
{
bool bRetour = false;
try
   {
   ASSERT(!aNom.IsEmpty() && !aLibelle.IsEmpty() && !aLogiciel.IsEmpty());
   ASSERT(!aLogiciel.AnsiPos(";"));

   if (!_VerifierVariable)
      {
      _VerifierVariable = (FctVerifierVariable)GetProcAddress(hEditeur, "_VerifierVariable" );
      if( !_VerifierVariable )
        throw EAbort("Impossible de charger la fonction _VerifierVariable");
      }

   bRetour = _VerifierVariable(aLogiciel, aCategorie, aNom, aLibelle, aValeur, bIsModifiableParUtilisateur);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(50), e);
   bRetour = false;
   }
return bRetour;
}

/*******************************************************************************
bool __fastcall CAccesCourrier::SupprimerVariable(const AnsiString &aLogiciel,
                                                  const AnsiString &aCategorie,
                                                  const AnsiString &aLibelle)

Fonction : Supprime la variable spécifiée

P.E : aLogiciel  : Logiciel
      aCategorie : Nom de la catégorie associée à la variable
      aLibelle   : Libellé de la variable

P.S : false si la variable ne peut pas être supprimée.
*******************************************************************************/
bool __fastcall CAccesCourrier::SupprimerVariable(const AnsiString &aLogiciel,
                                                  const AnsiString &aCategorie,
                                                  const AnsiString &aLibelle)
{
bool bRetour = false;
try
   {
   ASSERT(!aLogiciel.IsEmpty() && !aCategorie.IsEmpty() && !aLibelle.IsEmpty());

   if (!_SupprimerVariable)
      {
      _SupprimerVariable = (FctSupprimerVariable)GetProcAddress(hEditeur, "_SupprimerVariable");
      if( !_SupprimerVariable )
        throw EAbort("Impossible de charger la fonction _SupprimerVariable");
      }

   bRetour = _SupprimerVariable(aLogiciel, aCategorie, aLibelle);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(50), e);
   bRetour = false;
   }
return bRetour;
}

/*******************************************************************************
unsigned long __fastcall InitEmetDest(const AnsiString &aLogiciel,
                                      const AnsiString &aCategorie,
                                      unsigned long NumEmet, TStringList *slDest,
                                      const AnsiString &aLibelle = "",
                                      unsigned long NoCoord = 0);

Fonction :
     Initialise l'émetteur et les destinataires de chaque dossier liés au
     logiciel, à la catégorie et au modèle spécifié.
     Retourne le NoCoord lié à ce dossier.

P.E : NumEmet & slDest : Emetteur et destinataires qui seront séléctionnés par défaut.
      aLogiciel : le logiciel des courriers à initialiser
      aCategorie : la catégorie des courriers à initialiser
      aLibelle : Libellé du courrier à initialiser. S'il est vide, tous les modèles de la
                 catégorie seront initialisés.
      NoCoord : Coordonnés du dossier, s'il n'est pas connu, vaut 0.
                Dans ce cas, un nouveau numéro sera affecté et retourné par la fonction

P.S : NoCoord
*******************************************************************************/
unsigned long __fastcall CAccesCourrier::InitEmetDest(const AnsiString &aLogiciel,
                                                      const AnsiString &aCategorie,
                                                      unsigned long NumEmet, TStringList *slDest,
                                                      const AnsiString &aLibelle,
                                                      unsigned long NoCoord)
{
tMaillonNo *PremierMaillon = NULL, *MaillonPrec = NULL, *MaillonCourant = NULL;

try
   {
   ASSERT(!aLogiciel.IsEmpty());
   ASSERT(aLibelle.IsEmpty() || aLibelle.Length() > 8); //Temporaire : Si aLibelle <= 8 caractères ça doit être un nom de fichier au lieu d'un libellé

   if (!_IniCoordParDefaut)
      {
      _IniCoordParDefaut = (FctIniCoordParDefaut)GetProcAddress(hEditeur, "_IniCoordParDefaut" );
      if( !_IniCoordParDefaut )
        throw EAbort("Impossible de charger la fonction _IniCoordParDefaut");
      }

   for(int i=0 ; i<slDest->Count ; i++)
      {
      MaillonPrec = MaillonCourant;
      MaillonCourant = new tMaillonNo;
      MaillonCourant->NoCoord = slDest->Strings[i].ToInt();

      //1er passage => On vient de créer le 1er maillon
      if (!PremierMaillon)
         PremierMaillon = MaillonCourant;
      else
         MaillonPrec->MaillonSuiv = MaillonCourant;
      }

   nNoCoord = _IniCoordParDefaut(NumEmet, PremierMaillon, aLogiciel, aCategorie, aLibelle, NoCoord);

   MaillonCourant = PremierMaillon;
   while (MaillonCourant)
      {
      MaillonPrec = MaillonCourant;
      MaillonCourant = MaillonCourant->MaillonSuiv;
      delete MaillonPrec;          MaillonPrec = NULL;
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(60), e);
   }
return nNoCoord;
}

/*******************************************************************************
  unsigned long __fastcall InitEmetDest(const AnsiString &aLogiciel,
                                        const AnsiString &aCategorie,
                                        unsigned long NumEmet, unsigned long NumDest,
                                        const AnsiString aLibelle = "",
                                        unsigned long NoCoord = 0);

Fonction :
     Initialise l'émetteur et le destinataire de chaques dossiers liés au
     logiciel, à la catégorie et au courrier spécifié.
     Retourne le NoCoord lié à ce dossier.

P.E : NumEmet & NumDest : Emetteur et destinataire qui seront séléctionnés par défaut.
      aLogiciel : le logiciel des courriers à initialiser
      aCategorie : la catégorie des courriers à initialiser
      aCourrier : Nom du courrier à initialisé. S'il est vide, tous les courriers de la
                  catégorie seront initialisés.
      NoCoord : Coordonnés du dossier, s'il n'est pas connu, vaut 0.
                Dans ce cas, un nouveau numéro sera affecté et retourné par la fonction

P.S : NoCoord
*******************************************************************************/
unsigned long __fastcall CAccesCourrier::InitEmetDest(const AnsiString &aLogiciel,
                                                      const AnsiString &aCategorie,
                                                      unsigned long NumEmet, unsigned long NumDest,
                                                      const AnsiString &aLibelle,
                                                      unsigned long NoCoord)
{
TStringList *slDest = NULL;
unsigned long nNoCoord;
try
   {
   slDest = new TStringList;
   slDest->Add(NumDest);

   nNoCoord = InitEmetDest(aLogiciel, aCategorie, NumEmet, slDest, aLibelle, NoCoord);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(70), e);
   }
delete slDest;       slDest = NULL;
return nNoCoord;
}
/*******************************************************************************
   unsigned long __fastcall CompleteEmetDest(const AnsiString &aLogiciel,
                                             const AnsiString &aCategorie,
                                             unsigned long NumEmet, TStringList *slDest,
                                             const AnsiString &aLibelle = EmptyStr,
                                             unsigned long NoCoord = 0);

Fonction :
     Complète l'émetteur et les destinataires de chaques dossiers liés au
     logiciel, à la catégorie et au courrier spécifié s'ils sont absents.
     Retourne le NoCoord lié à ce dossier.

P.E : NumEmet & slDest : Emetteur et destinataires qui seront séléctionnés par défaut.
      aLogiciel : le logiciel des courriers à complèter
      aCategorie : la catégorie des courriers à complèter
      aLibelle : libellé du modèle à initialiser. S'il est vide, tous les courriers de la
                  catégorie seront initialisés.
      NoCoord : Coordonnés du dossier, s'il n'est pas connu, vaut 0.
                Dans ce cas, un nouveau numéro sera affecté et retourné par la fonction

P.S : NoCoord
*******************************************************************************/
unsigned long __fastcall CAccesCourrier::CompleteEmetDest(const AnsiString &aLogiciel,
                                                          const AnsiString &aCategorie,
                                                          unsigned long NumEmet, TStringList *slDest,
                                                          const AnsiString &aLibelle,
                                                          unsigned long NoCoord)
{
tMaillonNo *PremierMaillon = NULL, *MaillonPrec = NULL, *MaillonCourant = NULL;
try
   {
   ASSERT(!aLogiciel.IsEmpty());
   ASSERT(aLibelle.IsEmpty() || aLibelle.Length() > 8); //Temporaire : Si aLibelle <= 8 caractères ça doit être un nom de fichier au lieu d'un libellé

   if (!_IniCoordParDefaut)
      {
      _CompleteCoordParDefaut = (FctCompleteCoordParDefaut)GetProcAddress(hEditeur, "_CompleteCoordParDefaut" );
      if( !_CompleteCoordParDefaut )
        throw EAbort("Impossible de charger la fonction _CompleteCoordParDefaut");
      }

   for(int i=0 ; i<slDest->Count ; i++)
      {
      MaillonPrec = MaillonCourant;
      MaillonCourant = new tMaillonNo;
      MaillonCourant->NoCoord = slDest->Strings[i].ToInt();

      //1er passage => On vient de créer le 1er maillon
      if (!PremierMaillon)
         PremierMaillon = MaillonCourant;
      else
         MaillonPrec->MaillonSuiv = MaillonCourant;

      }

   nNoCoord = _CompleteCoordParDefaut(NumEmet, PremierMaillon, aLogiciel, aCategorie, aLibelle, NoCoord);

   MaillonCourant = PremierMaillon;
   while (MaillonCourant)
      {
      MaillonPrec = MaillonCourant;
      MaillonCourant = MaillonCourant->MaillonSuiv;
      delete MaillonPrec;          MaillonPrec = NULL;
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(80), e);
   }
return nNoCoord;
}
/*******************************************************************************
   unsigned long __fastcall CompleteEmetDest(const AnsiString &aLogiciel,
                                             const AnsiString &aCategorie,
                                             unsigned long NumEmet, unsigned long NumDest,
                                             const AnsiString &aCourrier = "",
                                             unsigned long NoCoord = 0);

Fonction :
     Complète l'émetteur et le destinataire de chaques dossiers liés au
     logiciel, à la catégorie et au modèle spécifié, s'ils sont absents.
     Retourne le NoCoord lié à ce dossier.

P.E : NumEmet & NumDest : Emetteur et destinataire qui seront séléctionnés par défaut.
      aLogiciel : le logiciel des courriers à complèter
      aCategorie : la catégorie des courriers à complèter
      aLibelle : Libellé du modèle à initialiser. S'il est vide, tous les courriers de la
                  catégorie seront initialisés.
      NoCoord : Coordonnés du dossier, s'il n'est pas connu, vaut 0.
                Dans ce cas, un nouveau numéro sera affecté et retourné par la fonction

P.S : NoCoord
*******************************************************************************/
unsigned long __fastcall CAccesCourrier::CompleteEmetDest(const AnsiString &aLogiciel,
                                                          const AnsiString &aCategorie,
                                                          unsigned long NumEmet, unsigned long NumDest,
                                                          const AnsiString &aLibelle,
                                                          unsigned long NoCoord)
{
TStringList *slDest = NULL;
unsigned long nNoCoord;
try
   {
   slDest = new TStringList;
   slDest->Add(NumDest);

   nNoCoord = CompleteEmetDest(aLogiciel, aCategorie, NumEmet, slDest, aLibelle, NoCoord);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(90), e);
   }
delete slDest;       slDest = NULL;
return nNoCoord;
}
/*******************************************************************************
   bool __fastcall GetListeEmetDest(const AnsiString &aLogiciel,
                                    const AnsiString &aCategorie,
                                    const AnsiString &aLibelle,
                                    unsigned long NoCoord,
                                    unsigned long *pNumEmet, TStringList *slDest
                                    );

Fonction : Charge les émetteur/destinataires liés au cooordonnés de recherche.

P.E :
      aLogiciel : le logiciel
      aCategorie :      et catégorie auquel il est lié
      aLibelle :     Libellé du courrier
      NoCoord : Numéro qui a été affecté aux coordonnées que vous voulez rechercher.

P.E. modifiés : pNumEmetteur : Numéro de l'émetteur trouvé.
                slDest : Numéros des destinataires.

P.S : true si quelquechose a été trouvé, sinon false
*******************************************************************************/
bool __fastcall CAccesCourrier::GetListeEmetDest(const AnsiString &aLogiciel,
                                                 const AnsiString &aCategorie,
                                                 const AnsiString &aLibelle,
                                                 unsigned long NoCoord,
                                                 unsigned long *pNumEmet, TStringList *slDest
                                                 )
{
tMaillonNo PremierMaillon, *MaillonPrec = NULL, *MaillonCourant = NULL;
bool bRetour = false;
try
   {
   ASSERT(pNumEmet && slDest);
   ASSERT(!aLogiciel.IsEmpty() && !aCategorie.IsEmpty() && !aLibelle.IsEmpty());
   ASSERT(aLibelle.IsEmpty() || aLibelle.Length() > 8); //Temporaire : Si aLibelle <= 8 caractères ça doit être un nom de fichier au lieu d'un libellé

   if (!_GetListeEmetDest)
      {
      _GetListeEmetDest = (FctGetListeEmetDest)GetProcAddress(hEditeur, "_GetListeEmetDest");
      if( !_GetListeEmetDest )
        throw EAbort("Impossible de charger la fonction _GetListeEmetDest");
      }

   slDest->Clear();

   bRetour = _GetListeEmetDest(aLogiciel, aCategorie, aLibelle, NoCoord, pNumEmet, &PremierMaillon);

   MaillonCourant = &PremierMaillon;
   while (MaillonCourant)
      {
      if (MaillonCourant->NoCoord)
         slDest->Add(MaillonCourant->NoCoord);

      MaillonPrec = MaillonCourant;
      MaillonCourant = MaillonCourant->MaillonSuiv;
      if (MaillonPrec != &PremierMaillon)
         {
         delete MaillonPrec;          MaillonPrec = NULL;
         }
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(80), e);
   }
return bRetour;
}

/*******************************************************************************
bool __fastcall CAccesCourrier::RenommerModele(const AnsiString &aOldLogiciel,
                                               const AnsiString &aOldCategorie,
                                               const AnsiString &aOldLibelle,
                                               const AnsiString &aNewLogiciel,
                                               const AnsiString &aNewCategorie,
                                               const AnsiString &aNewLibelle)

Fonction : Permet de modifier le logiciel, la catégorie d'un modèle.

Paramètres d'entrée : aOldLogiciel  : Logiciel associé au modèle
                      aOldCategorie : Catégorie associé au modèle
                      aOldLibelle   : Libellé du modèle
                      aNewLogiciel  : Nouveau logiciel associé au modèle
                                      Si aNewLogiciel est vide, le nom du logiciel n'est pas modifié
                      aNewCategorie : Nouvelle catégorie associé au modèle
                                      Si aNewCategorie est vide, la catégorie du logiciel n'est pas modifié
                      aNewLibelle   : Nouveau libellé du modèle
                                      Si aNewLibelle est vide, le libellé du logiciel n'est pas modifié

Valeur retournée :
*******************************************************************************/
bool __fastcall CAccesCourrier::RenommerModele(const AnsiString &aOldLogiciel,
                                               const AnsiString &aOldCategorie,
                                               const AnsiString &aOldLibelle,
                                               const AnsiString &aNewLogiciel,
                                               const AnsiString &aNewCategorie,
                                               const AnsiString &aNewLibelle)
{
try
   {
   if (!_RenommerModele)
      {
      _RenommerModele = (FctRenommerModele)GetProcAddress(hEditeur, "_RenommerModele");
      if(!_RenommerModele)
         throw EAbort("Impossible de charger la fonction _RenommerModele");
      }

   return _RenommerModele(aOldLogiciel, aOldCategorie, aOldLibelle,
                          aNewLogiciel, aNewCategorie, aNewLibelle);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(85), e);
   }
return false;
}

/*******************************************************************************
bool __fastcall CAccesCourrier::SupprimerModele(const AnsiString &aLogiciel,
                                                const AnsiString &aCategorie,
                                                const AnsiString &aLibelle)

Fonction : Supprime les fichiers .pro et .rtf du modèle.
           Supprime l'enregistrement de la table TableDoc.
           Supprime les liens de la table ListFich.
           Supprime les liens de la table CoordDoss.

*******************************************************************************/
bool __fastcall CAccesCourrier::SupprimerModele(const AnsiString &aLogiciel,
                                                const AnsiString &aCategorie,
                                                const AnsiString &aLibelle)
{
bool bRetour = false;
try
   {
   ASSERT(!aLogiciel.IsEmpty() && !aCategorie.IsEmpty() && !aLibelle.IsEmpty());

   if (!_SupprimerModele)
      {
      _SupprimerModele = (FctSupprimerModele)GetProcAddress(hEditeur, "_SupprimerModele" );
      if( !_SupprimerModele )
        throw EAbort("Impossible de charger la fonction _SupprimerModele");
      }

   bRetour = _SupprimerModele(aLogiciel, aCategorie, aLibelle);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(90), e);
   bRetour = false;
   }
return bRetour;
}

/*******************************************************************************
void __fastcall CAccesCourrier::ModifierModele (const AnsiString &aLogiciel,
                                                const AnsiString &aCategorie,
                                                const AnsiString &aCategorieVariables,
                                                const AnsiString &aLibelle,
                                                IDLangue eLangue,
                                                IDOrientation eOrientation,
                                                bool bGererEnTeteEtPiedDePage,
                                                const AnsiString &aRepSecondaire = EmptyStr,
                                                eNivModele eNoModeleSecondaire = eNivPrimaire,
                                                const TContrainteTaille *sContrainteTaille = NULL
                                                )

Fonction : Permet d'éditer de fichier modèle spécifié. Si un répertoire secondaire,
           est précisé, le fichier édité sera celui de ce répertoire. En cas d'absence,
           il sera généré à partir du répertoire standard.

Paramètres d'entrée : aLogiciel                : Logiciel auquel appartient le modèle
                      aCategorie               : Catégorie à laquelle appartient le modèle
                      aCategorieVariables      : Catégorie des variables qui seront visibles
                      aLibelle                 : Libellé associèe au modèle
                      eLangue                  : Langue du modèle
                      eOrientation             : Orientation du modèle
                      bGererEnTeteEtPiedDePage :
                      aRepSecondaire           : Répertoire secondaire où aller chercher le modèle
                      eNoModeleSecondaire      : Numéro d'ordre du modèle secondaire
                      sContrainteTaille        : Contrainte d'édition
*******************************************************************************/
bool __fastcall CAccesCourrier::ModifierModele (const AnsiString &aLogiciel,
                                                const AnsiString &aCategorie,
                                                const AnsiString &aCategorieVariables,
                                                const AnsiString &aLibelle,
                                                IDLangue eLangue,
                                                IDOrientation eOrientation,
                                                bool bGererEnTeteEtPiedDePage,
                                                const AnsiString &aRepSecondaire/* = EmptyStr*/,
                                                eNivModele eNoModeleSecondaire/* = eNivPrimaire*/,
                                                const TContrainteTaille *sContrainteTaille /*= NULL*/
                                                )
{
try
   {
   if (!_ModifierModele)
      {
      _ModifierModele = (FctModifierModele)GetProcAddress(hEditeur, "_ModifierModele");
      if( !_ModifierModele )
        throw EAbort("Impossible de charger la fonction _ModifierModele");
      }

   return _ModifierModele(aLogiciel,
                          aCategorie,
                          aCategorieVariables,
                          aLibelle,
                          eLangue,
                          eOrientation,
                          bGererEnTeteEtPiedDePage,
                          aRepSecondaire,
                          eNoModeleSecondaire,
                          sContrainteTaille
                          );
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(100), e);
   return false;
   }
}

/*******************************************************************************
void CAccesCourrier::SupprimerModelesSecondaire(const AnsiString &aLogiciel,
                                                const AnsiString &aCategorie,
                                                const AnsiString &aLibelle,
                                                IDLangue eLangue,
                                                IDOrientation eOrientation,
                                                const AnsiString &aRepSecondaire,
                                                eNivModele eNoModeleSecondaire);

Fonction : Supprime les modèles secondaires.

Paramètres d'entrée : aLogiciel    : Logiciel utilisé pour filtrer les modèles à supprimer. Peut être vide => Supprime pour tous les logiciels
                      aCategorie   : Categorie utilisée pour filtrer les modèles à supprimer. Peut être vide => Supprime pour toutes les catégories
                      aLibelle     : Libellé utilisé pour filtrer les modèles à supprimer. Peut être vide => Supprime pour tous les libellés
                      eLangue      : Langue utilisée pour filtrer les modèles à supprimer. Peut valoir NB_LANGUES => Supprime pour toutes les langues
                      eOrientation : Orientation utilisée pour filtrer les modèles à supprimer. Peut valoir NB_ORIENTATIONS => Supprime pour toutes les orientations
                      aRepSecondaire : Répertoire où se trouve les modèles secondaire
                      eNoModeleSecondaire : Niveau du modèle sec. à supprimer.
                                            Si eNivAucun, tous les modèles sec. seront supprimés
*******************************************************************************/
void __fastcall CAccesCourrier::SupprimerModelesSecondaire(const AnsiString &aLogiciel,
                                                           const AnsiString &aCategorie,
                                                           const AnsiString &aLibelle,
                                                           IDLangue eLangue,
                                                           IDOrientation eOrientation,
                                                           const AnsiString &aRepSecondaire,
                                                           eNivModele eNoModeleSecondaire)

{
try
   {
   if (!_SupprimerModelesSecondaire)
      {
      _SupprimerModelesSecondaire = (FctSupprimerModelesSecondaire)GetProcAddress(hEditeur, "_SupprimerModelesSecondaire");
      if( !_SupprimerModelesSecondaire)
        throw EAbort("Impossible de charger la fonction _SupprimerModelesSecondaire");
      }

   _SupprimerModelesSecondaire(aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, aRepSecondaire, eNoModeleSecondaire);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(110), e);
   }
}
/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
bool __fastcall CAccesCourrier::DonneesSontTrouveesDansTable(TTypeTblCour eTypeTable,
                                                             const AnsiString &aLogiciel)
{
try
   {
   if (!_DonneesSontTrouveesDansTable)
      {
      _DonneesSontTrouveesDansTable = (FctDonneesSontTrouveesDansTable)GetProcAddress(hEditeur, "_DonneesSontTrouveesDansTable");
      if( !_DonneesSontTrouveesDansTable )
        throw EAbort( "Impossible de charger la fonction _DonneesSontTrouveesDansTable.");
      }

   return _DonneesSontTrouveesDansTable(eTypeTable, aLogiciel);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(120), e);
   return false;
   }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
bool CAccesCourrier::GetDescriptifModele(const AnsiString &aLogiciel,
                                         const AnsiString &aCategorie,
                                         const AnsiString &aLibelle,
                                         TDescriptifModele *sDescriptifModele)
{
;
try
   {
   if (!_GetDescriptifModele)
      {
      _GetDescriptifModele = (FctGetDescriptifModele)GetProcAddress(hEditeur, "_GetDescriptifModele");
      if( !_GetDescriptifModele )
        throw EAbort( "Impossible de charger la fonction _GetDescriptifModele.");
      }

   return _GetDescriptifModele(aLogiciel, aCategorie, aLibelle, sDescriptifModele);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(130), e);
   }
return false;
}

/*******************************************************************************
AnsiString __fastcall CAccesCourrier::GetNomFichier(const AnsiString &aLogiciel,
                                                    const AnsiString &aCategorie,
                                                    const AnsiString &aLibelle,
                                                    IDLangue eLangue,
                                                    IDOrientation eOrientation,
                                                    const AnsiString &aRepSecondaire,
                                                    eNivModele eNoModeleSecondaire
                                                    )

Fonction :

Paramètres d'entrée :
                      eNoModeleSecondaire : Numéro d'ordre du modèle secondaire (1 à 9)

Paramètres de sortie :

Valeur retournée : Retourne le nom complet du fichier "M_CO_001.RTF" ou une chaine
                   vide si le fichier n'existe pas.
*******************************************************************************/
AnsiString __fastcall CAccesCourrier::GetNomFichier(const AnsiString &aLogiciel,
                                                    const AnsiString &aCategorie,
                                                    const AnsiString &aLibelle,
                                                    IDLangue eLangue,
                                                    IDOrientation eOrientation,
                                                    const AnsiString &aRepSecondaire /*= EmptyStr*/,
                                                    eNivModele eNoModeleSecondaire /*=eNivPrimaire*/
                                                    )
{
try
   {
   if (!_GetNomFichier)
      {
      _GetNomFichier = (FctGetNomFichier)GetProcAddress(hEditeur, "_GetNomFichier");
      if( !_GetNomFichier )
        throw EAbort( "Impossible de charger la fonction _GetNomFichier.");
      }

   return _GetNomFichier(aLogiciel, aCategorie, aLibelle, eLangue, eOrientation, aRepSecondaire, eNoModeleSecondaire);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(140), e);
   }
return EmptyStr;
}

/*******************************************************************************
bool GetInfosFichierModele(const AnsiString &aCourrier,
                           AnsiString *aLogiciel,
                           AnsiString *aCategorie,
                           AnsiString *aLibelle,
                           IDLangue *eLangue,
                           IDOrientation *eOrientation);

Fonction : Retrouve le logiciel, la catégorie et libellé d'un modèle à partir
           du nom de fichier.

Paramètres d'entrée : aCourrier

Paramètres de sortie : aLogiciel  : Peut-être NULL
                       aCategorie : Peut-être NULL
                       aLibelle   : Peut-être NULL
Valeur retournée : false si le fichier n'existe pas.
*******************************************************************************/
bool CAccesCourrier::GetInfosFichierModele(const AnsiString &aCourrier,
                                           AnsiString *aLogiciel,
                                           AnsiString *aCategorie,
                                           AnsiString *aLibelle,
                                           IDLangue *eLangue,
                                           IDOrientation *eOrientation)
{
FctGetInfosFichierModele _GetInfosFichierModele = NULL;
bool bValRetour;
try
   {
   ASSERT(hEditeur);
   if (!_GetInfosFichierModele)
      {
      _GetInfosFichierModele = (FctGetInfosFichierModele)GetProcAddress(hEditeur, "_GetInfosFichierModele");
      if( !_GetInfosFichierModele)
        throw EAbort("Impossible de charger la fonction _GetInfosFichierModele");
      }

   bValRetour = _GetInfosFichierModele(aCourrier, aLogiciel, aCategorie, aLibelle, eLangue, eOrientation);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(150), e);
   }

return bValRetour;
}

/*******************************************************************************
void __fastcall CAccesCourrier::SignalerUtilisationDuModele(short shIDUser,
                                                            const AnsiString &aLogiciel,
                                                            const AnsiString &aCategorie,
                                                            const AnsiString &aLibelle,
                                                            const AnsiString &aRepDossier)

Fonction : Informe l'éditeur de modèle que le modèle spécifié est utilisé par
   l'application (Utilisé pour sauvegarder les modèles).
   Une table "d'index" sera alors créé dans le répertoire aRepDossier.

Paramètres d'entrée : shIDUser : Identification d'utilisation du modèle dans l'application appelante.
                                 (Ex : Si le modèle choisi comme lettre d'acompagnement est Modele1,
                                 et si l'utilisateur change et choisi Modele2, lors du signalement,
                                 l'éditeur de courrier doit savoir que le modèle précedemment sélectionné
                                 était Modele1, pour le supprimer de la liste des modèles utilisé.
                                 En affectant un n° d'ID au modèle lettre d'accompagnement, il saura
                                 quel est le modèle précédemment associé à cet ID).
                      aLogiciel   : Logiciel du modèle
                      aCategorie  : Catégorie du modèle
                      aLibelle    : Libellé du modèle
                      aRepDossier : Dossier

*******************************************************************************/
void __fastcall CAccesCourrier::SignalerUtilisationDuModele(short shIDUser,
                                                            const AnsiString &aLogiciel,
                                                            const AnsiString &aCategorie,
                                                            const AnsiString &aLibelle,
                                                            const AnsiString &aRepDossier)
{
try
   {
   if (!_EnregistrerModReq)
      {
      _EnregistrerModReq = (FctEnregistrerModReq)GetProcAddress(hEditeur, "_EnregistrerModReq");
      if(!_EnregistrerModReq)
        throw EAbort("Impossible de charger la fonction _EnregistrerModReq");
      }

   ASSERT(!aRepDossier.IsEmpty());
   _EnregistrerModReq(shIDUser,
                      aLogiciel,
                      aCategorie,
                      aLibelle,
                      aRepDossier);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(160), e);
   }
}

